home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 4 / QRZ Ham Radio Callsign Database - Volume 4.iso / files / dsp / 56ktools / dspkgctr.z / dspkgctr / gcc / cexp.y < prev    next >
Text File  |  1992-06-08  |  15KB  |  667 lines
  1. /* $Id: cexp.y,v 1.2 92/04/02 14:39:53 pete Exp $ */
  2. /* Parse C expressions for CCCP.
  3.    Copyright (C) 1987 Free Software Foundation.
  4.  
  5. This program is free software; you can redistribute it and/or modify it
  6. under the terms of the GNU General Public License as published by the
  7. Free Software Foundation; either version 1, or (at your option) any
  8. later version.
  9.  
  10. This program is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. GNU General Public License for more details.
  14.  
  15. You should have received a copy of the GNU General Public License
  16. along with this program; if not, write to the Free Software
  17. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  
  19.  In other words, you are welcome to use, share and improve this program.
  20.  You are forbidden to forbid anyone else to use, share and improve
  21.  what you give them.   Help stamp out software-hoarding!
  22.  
  23.  Adapted from expread.y of GDB by Paul Rubin, July 1986.
  24.  
  25. /* Parse a C expression from text in a string  */
  26.    
  27. %{
  28. #include "config.h"
  29. #include <setjmp.h>
  30. /* #define YYDEBUG 1 */
  31.  
  32. /* forward external function declarations */
  33. #if defined( _MSDOS )
  34.   int error ( char * msg, ... );
  35.   int warning ( char * msg, ... );
  36. #endif
  37.  
  38.   int yylex ();
  39.   void yyerror ();
  40.   int expression_value;
  41.  
  42.   static jmp_buf parse_return_error;
  43.  
  44.   /* some external tables of character types */
  45.   extern unsigned char is_idstart[], is_idchar[];
  46.  
  47. #ifndef CHAR_TYPE_SIZE
  48. #define CHAR_TYPE_SIZE BITS_PER_UNIT
  49. #endif
  50. %}
  51.  
  52. %union {
  53.   struct constant {long value; int unsignedp;} integer;
  54.   int voidval;
  55.   char *sval;
  56. }
  57.  
  58. %type <integer> exp exp1 start
  59. %token <integer> INT CHAR
  60. %token <sval> NAME
  61. %token <integer> ERROR
  62.  
  63. %right '?' ':'
  64. %left ','
  65. %left OR
  66. %left AND
  67. %left '|'
  68. %left '^'
  69. %left '&'
  70. %left EQUAL NOTEQUAL
  71. %left '<' '>' LEQ GEQ
  72. %left LSH RSH
  73. %left '+' '-'
  74. %left '*' '/' '%'
  75. %right UNARY
  76.  
  77. /* %expect 40 */
  78.  
  79. %%
  80.  
  81. start   :    exp1
  82.         { expression_value = $1.value; }
  83.     ;
  84.  
  85. /* Expressions, including the comma operator.  */
  86. exp1    :    exp
  87.     |    exp1 ',' exp
  88.             { $$ = $3; }
  89.     ;
  90.  
  91. /* Expressions, not including the comma operator.  */
  92. exp    :    '-' exp    %prec UNARY
  93.             { $$.value = - $2.value;
  94.               $$.unsignedp = $2.unsignedp; }
  95.     |    '!' exp    %prec UNARY
  96.             { $$.value = ! $2.value;
  97.               $$.unsignedp = 0; }
  98.     |    '+' exp    %prec UNARY
  99.             { $$ = $2; }
  100.     |    '~' exp    %prec UNARY
  101.             { $$.value = ~ $2.value;
  102.               $$.unsignedp = $2.unsignedp; }
  103.     |    '(' exp1 ')'
  104.             { $$ = $2; }
  105.     ;
  106.  
  107. /* Binary operators in order of decreasing precedence.  */
  108. exp    :    exp '*' exp
  109.             { $$.unsignedp = $1.unsignedp || $3.unsignedp;
  110.               if ($$.unsignedp)
  111.                 $$.value = (unsigned) $1.value * $3.value;
  112.               else
  113.                 $$.value = $1.value * $3.value; }
  114.     |    exp '/' exp
  115.             { if ($3.value == 0)
  116.                 {
  117.                   error ("division by zero in #if");
  118.                   $3.value = 1;
  119.                 }
  120.               $$.unsignedp = $1.unsignedp || $3.unsignedp;
  121.               if ($$.unsignedp)
  122.                 $$.value = (unsigned) $1.value / $3.value;
  123.               else
  124.                 $$.value = $1.value / $3.value; }
  125.     |    exp '%' exp
  126.             { if ($3.value == 0)
  127.                 {
  128.                   error ("division by zero in #if");
  129.                   $3.value = 1;
  130.                 }
  131.               $$.unsignedp = $1.unsignedp || $3.unsignedp;
  132.               if ($$.unsignedp)
  133.                 $$.value = (unsigned) $1.value % $3.value;
  134.               else
  135.                 $$.value = $1.value % $3.value; }
  136.     |    exp '+' exp
  137.             { $$.value = $1.value + $3.value;
  138.               $$.unsignedp = $1.unsignedp || $3.unsignedp; }
  139.     |    exp '-' exp
  140.             { $$.value = $1.value - $3.value;
  141.               $$.unsignedp = $1.unsignedp || $3.unsignedp; }
  142.     |    exp LSH exp
  143.             { $$.unsignedp = $1.unsignedp;
  144.               if ($$.unsignedp)
  145.                 $$.value = (unsigned) $1.value << $3.value;
  146.               else
  147.                 $$.value = $1.value << $3.value; }
  148.     |    exp RSH exp
  149.             { $$.unsignedp = $1.unsignedp;
  150.               if ($$.unsignedp)
  151.                 $$.value = (unsigned) $1.value >> $3.value;
  152.               else
  153.                 $$.value = $1.value >> $3.value; }
  154.     |    exp EQUAL exp
  155.             { $$.value = ($1.value == $3.value);
  156.               $$.unsignedp = 0; }
  157.     |    exp NOTEQUAL exp
  158.             { $$.value = ($1.value != $3.value);
  159.               $$.unsignedp = 0; }
  160.     |    exp LEQ exp
  161.             { $$.unsignedp = 0;
  162.               if ($1.unsignedp || $3.unsignedp)
  163.                 $$.value = (unsigned) $1.value <= $3.value;
  164.               else
  165.                 $$.value = $1.value <= $3.value; }
  166.     |    exp GEQ exp
  167.             { $$.unsignedp = 0;
  168.               if ($1.unsignedp || $3.unsignedp)
  169.                 $$.value = (unsigned) $1.value >= $3.value;
  170.               else
  171.                 $$.value = $1.value >= $3.value; }
  172.     |    exp '<' exp
  173.             { $$.unsignedp = 0;
  174.               if ($1.unsignedp || $3.unsignedp)
  175.                 $$.value = (unsigned) $1.value < $3.value;
  176.               else
  177.                 $$.value = $1.value < $3.value; }
  178.     |    exp '>' exp
  179.             { $$.unsignedp = 0;
  180.               if ($1.unsignedp || $3.unsignedp)
  181.                 $$.value = (unsigned) $1.value > $3.value;
  182.               else
  183.                 $$.value = $1.value > $3.value; }
  184.     |    exp '&' exp
  185.             { $$.value = $1.value & $3.value;
  186.               $$.unsignedp = $1.unsignedp || $3.unsignedp; }
  187.     |    exp '^' exp
  188.             { $$.value = $1.value ^ $3.value;
  189.               $$.unsignedp = $1.unsignedp || $3.unsignedp; }
  190.     |    exp '|' exp
  191.             { $$.value = $1.value | $3.value;
  192.               $$.unsignedp = $1.unsignedp || $3.unsignedp; }
  193.     |    exp AND exp
  194.             { $$.value = ($1.value && $3.value);
  195.               $$.unsignedp = 0; }
  196.     |    exp OR exp
  197.             { $$.value = ($1.value || $3.value);
  198.               $$.unsignedp = 0; }
  199.     |    exp '?' exp ':' exp
  200.             { $$.value = $1.value ? $3.value : $5.value;
  201.               $$.unsignedp = $3.unsignedp || $5.unsignedp; }
  202.     |    INT
  203.             { $$ = yylval.integer; }
  204.     |    CHAR
  205.             { $$ = yylval.integer; }
  206.     |    NAME
  207.             { $$.value = 0;
  208.               $$.unsignedp = 0; }
  209.     ;
  210. %%
  211.  
  212.  
  213. /* During parsing of a C expression, the pointer to the next character
  214.    is in this variable.  */
  215.  
  216. static char *lexptr;
  217.  
  218. /* Take care of parsing a number (anything that starts with a digit).
  219.    Set yylval and return the token type; update lexptr.
  220.    LEN is the number of characters in it.  */
  221.  
  222. /* maybe needs to actually deal with floating point numbers */
  223.  
  224. int
  225. parse_number (olen)
  226.      int olen;
  227. {
  228.   register char *p = lexptr;
  229.   register long n = 0;
  230.   register int c;
  231.   register int base = 10;
  232.   register int len = olen;
  233.  
  234.   for (c = 0; c < len; c++)
  235.     if (p[c] == '.') {
  236.       /* It's a float since it contains a point.  */
  237.       yyerror ("floating point numbers not allowed in #if expressions");
  238.       return ERROR;
  239.     }
  240.  
  241.   yylval.integer.unsignedp = 0;
  242.  
  243.   if (len >= 3 && (!strncmp (p, "0x", 2) || !strncmp (p, "0X", 2))) {
  244.     p += 2;
  245.     base = 16;
  246.     len -= 2;
  247.   }
  248.   else if (*p == '0')
  249.     base = 8;
  250.  
  251.   while (len > 0) {
  252.     c = *p++;
  253.     len--;
  254.     if (c >= 'A' && c <= 'Z') c += 'a' - 'A';
  255.  
  256.     if (c >= '0' && c <= '9') {
  257.       n *= base;
  258.       n += c - '0';
  259.     } else if (base == 16 && c >= 'a' && c <= 'f') {
  260.       n *= base;
  261.       n += c - 'a' + 10;
  262.     } else {
  263.       /* `l' means long, and `u' means unsigned.  */
  264.       while (1) {
  265.     if (c == 'l' || c == 'L')
  266.       ;
  267.     else if (c == 'u' || c == 'U')
  268.       yylval.integer.unsignedp = 1;
  269.     else
  270.       break;
  271.  
  272.     if (len == 0)
  273.       break;
  274.     c = *p++;
  275.     len--;
  276.       }
  277.       /* Don't look for any more digits after the suffixes.  */
  278.       break;
  279.     }
  280.   }
  281.  
  282.   if (len != 0) {
  283.     yyerror ("Invalid number in #if expression");
  284.     return ERROR;
  285.   }
  286.  
  287.   /* If too big to be signed, consider it unsigned.  */
  288.   if (n < 0)
  289.     yylval.integer.unsignedp = 1;
  290.  
  291.   lexptr = p;
  292.   yylval.integer.value = n;
  293.   return INT;
  294. }
  295.  
  296. struct token {
  297.   char *operator;
  298.   int token;
  299. };
  300.  
  301. #ifndef NULL
  302. #define NULL 0
  303. #endif
  304.  
  305. static struct token tokentab2[] = {
  306.   {"&&", AND},
  307.   {"||", OR},
  308.   {"<<", LSH},
  309.   {">>", RSH},
  310.   {"==", EQUAL},
  311.   {"!=", NOTEQUAL},
  312.   {"<=", LEQ},
  313.   {">=", GEQ},
  314.   {NULL, ERROR}
  315. };
  316.  
  317. /* Read one token, getting characters through lexptr.  */
  318.  
  319. int
  320. yylex ()
  321. {
  322.   register int c;
  323.   register int namelen;
  324.   register char *tokstart;
  325.   register struct token *toktab;
  326.  
  327.  retry:
  328.  
  329.   tokstart = lexptr;
  330.   c = *tokstart;
  331.   /* See if it is a special token of length 2.  */
  332.   for (toktab = tokentab2; toktab->operator != NULL; toktab++)
  333.     if (c == *toktab->operator && tokstart[1] == toktab->operator[1]) {
  334.       lexptr += 2;
  335.       return toktab->token;
  336.     }
  337.  
  338.   switch (c) {
  339.   case 0:
  340.     return 0;
  341.     
  342.   case ' ':
  343.   case '\t':
  344.   case '\n':
  345.     lexptr++;
  346.     goto retry;
  347.     
  348.   case '\'':
  349.     lexptr++;
  350.     c = *lexptr++;
  351.     if (c == '\\')
  352.       c = parse_escape (&lexptr);
  353.  
  354. #if ! defined( DSP96000 )
  355.     /* Sign-extend the constant if chars are signed on target machine.  */
  356.     {
  357.       if (lookup ("__CHAR_UNSIGNED__", sizeof ("__CHAR_UNSIGNED__")-1, -1)
  358.       || ((c >> (CHAR_TYPE_SIZE - 1)) & 1) == 0)
  359.     yylval.integer.value = c & ((1 << CHAR_TYPE_SIZE) - 1);
  360.       else
  361.     yylval.integer.value = c | ~((1 << CHAR_TYPE_SIZE) - 1);
  362.     }
  363. #else
  364.     /* not done on the 96k because the CHAR_TYPE_SIZE is the same as the
  365.        hosts int size */
  366.     yylval.integer.value = c;
  367. #endif
  368.  
  369.     yylval.integer.unsignedp = 0;
  370.     c = *lexptr++;
  371.     if (c != '\'') {
  372.       yyerror ("Invalid character constant in #if");
  373.       return ERROR;
  374.     }
  375.     
  376.     return CHAR;
  377.  
  378.     /* some of these chars are invalid in constant expressions;
  379.        maybe do something about them later */
  380.   case '/':
  381.   case '+':
  382.   case '-':
  383.   case '*':
  384.   case '%':
  385.   case '|':
  386.   case '&':
  387.   case '^':
  388.   case '~':
  389.   case '!':
  390.   case '@':
  391.   case '<':
  392.   case '>':
  393.   case '(':
  394.   case ')':
  395.   case '[':
  396.   case ']':
  397.   case '.':
  398.   case '?':
  399.   case ':':
  400.   case '=':
  401.   case '{':
  402.   case '}':
  403.   case ',':
  404.     lexptr++;
  405.     return c;
  406.     
  407.   case '"':
  408.     yyerror ("double quoted strings not allowed in #if expressions");
  409.     return ERROR;
  410.   }
  411.   if (c >= '0' && c <= '9') {
  412.     /* It's a number */
  413.     for (namelen = 0;
  414.      c = tokstart[namelen], is_idchar[c] || c == '.'; 
  415.      namelen++)
  416.       ;
  417.     return parse_number (namelen);
  418.   }
  419.   
  420.   if (!is_idstart[c]) {
  421.     yyerror ("Invalid token in expression");
  422.     return ERROR;
  423.   }
  424.   
  425.   /* It is a name.  See how long it is.  */
  426.   
  427.   for (namelen = 0; is_idchar[tokstart[namelen]]; namelen++)
  428.     ;
  429.   
  430.   lexptr += namelen;
  431.   return NAME;
  432. }
  433.  
  434.  
  435. /* Parse a C escape sequence.  STRING_PTR points to a variable
  436.    containing a pointer to the string to parse.  That pointer
  437.    is updated past the characters we use.  The value of the
  438.    escape sequence is returned.
  439.  
  440.    A negative value means the sequence \ newline was seen,
  441.    which is supposed to be equivalent to nothing at all.
  442.  
  443.    If \ is followed by a null character, we return a negative
  444.    value and leave the string pointer pointing at the null character.
  445.  
  446.    If \ is followed by 000, we return 0 and leave the string pointer
  447.    after the zeros.  A value of 0 does not mean end of string.  */
  448.  
  449. int
  450. parse_escape (string_ptr)
  451.      char **string_ptr;
  452. {
  453.   register int c = *(*string_ptr)++;
  454.   switch (c)
  455.     {
  456.     case 'a':
  457.       return TARGET_BELL;
  458.     case 'b':
  459.       return TARGET_BS;
  460.     case 'e':
  461.       return 033;
  462.     case 'f':
  463.       return TARGET_FF;
  464.     case 'n':
  465.       return TARGET_NEWLINE;
  466.     case 'r':
  467.       return TARGET_CR;
  468.     case 't':
  469.       return TARGET_TAB;
  470.     case 'v':
  471.       return TARGET_VT;
  472.     case '\n':
  473.       return -2;
  474.     case 0:
  475.       (*string_ptr)--;
  476.       return 0;
  477.     case '^':
  478.       c = *(*string_ptr)++;
  479.       if (c == '\\')
  480.     c = parse_escape (string_ptr);
  481.       if (c == '?')
  482.     return 0177;
  483.       return (c & 0200) | (c & 037);
  484.       
  485.     case '0':
  486.     case '1':
  487.     case '2':
  488.     case '3':
  489.     case '4':
  490.     case '5':
  491.     case '6':
  492.     case '7':
  493.       {
  494.     register int i = c - '0';
  495.     register int count = 0;
  496.     while (++count < 3)
  497.       {
  498.         c = *(*string_ptr)++;
  499.         if (c >= '0' && c <= '7')
  500.           i = (i << 3) + c - '0';
  501.         else
  502.           {
  503.         (*string_ptr)--;
  504.         break;
  505.           }
  506.       }
  507. #if ! defined( DSP96000 )
  508.     /* not done on the 96k because the CHAR_TYPE_SIZE is the same as the
  509.        hosts int size. Someday, we (i) can make this a universal and more
  510.        correct fix. */
  511.  
  512.     if ((i & ~((1 << CHAR_TYPE_SIZE) - 1)) != 0)
  513.       {
  514.         i &= (1 << CHAR_TYPE_SIZE) - 1;
  515.         warning ("octal character constant does not fit in a byte");
  516.       }
  517. #endif
  518.  
  519.     return i;
  520.       }
  521.     case 'x':
  522.       {
  523.     register int i = 0;
  524.     register int count = 0;
  525.     for (;;)
  526.       {
  527.         c = *(*string_ptr)++;
  528.         if (c >= '0' && c <= '9')
  529.           i = (i << 4) + c - '0';
  530.         else if (c >= 'a' && c <= 'f')
  531.           i = (i << 4) + c - 'a' + 10;
  532.         else if (c >= 'A' && c <= 'F')
  533.           i = (i << 4) + c - 'A' + 10;
  534.         else
  535.           {
  536.         (*string_ptr)--;
  537.         break;
  538.           }
  539.       }
  540.     if ((i & ~((1 << BITS_PER_UNIT) - 1)) != 0)
  541.       {
  542.         i &= (1 << BITS_PER_UNIT) - 1;
  543.         warning ("hex character constant does not fit in a byte");
  544.       }
  545.     return i;
  546.       }
  547.     default:
  548.       return c;
  549.     }
  550. }
  551.  
  552. void
  553. yyerror (s)
  554.      char *s;
  555. {
  556.   error (s);
  557.   longjmp (parse_return_error, 1);
  558. }
  559.  
  560. /* This page contains the entry point to this file.  */
  561.  
  562. /* Parse STRING as an expression, and complain if this fails
  563.    to use up all of the contents of STRING.  */
  564. /* We do not support C comments.  They should be removed before
  565.    this function is called.  */
  566.  
  567. int
  568. parse_c_expression (string)
  569.      char *string;
  570. {
  571.   lexptr = string;
  572.   
  573.   if (lexptr == 0 || *lexptr == 0) {
  574.     error ("empty #if expression");
  575.     return 0;            /* don't include the #if group */
  576.   }
  577.  
  578.   /* if there is some sort of scanning error, just return 0 and assume
  579.      the parsing routine has printed an error message somewhere.
  580.      there is surely a better thing to do than this.     */
  581.   if (setjmp (parse_return_error))
  582.     return 0;
  583.  
  584.   if (yyparse ())
  585.     return 0;            /* actually this is never reached
  586.                    the way things stand. */
  587.   if (*lexptr)
  588.     error ("Junk after end of expression.");
  589.  
  590.   return expression_value;    /* set by yyparse () */
  591. }
  592.  
  593. #ifdef TEST_EXP_READER
  594. /* main program, for testing purposes. */
  595. main ()
  596. {
  597.   int n, c;
  598.   char buf[1024];
  599.   extern int yydebug;
  600. /*
  601.   yydebug = 1;
  602. */
  603.   initialize_random_junk ();
  604.  
  605.   for (;;) {
  606.     printf ("enter expression: ");
  607.     n = 0;
  608.     while ((buf[n] = getchar ()) != '\n' && buf[n] != EOF)
  609.       n++;
  610.     if (buf[n] == EOF)
  611.       break;
  612.     buf[n] = '\0';
  613.     printf ("parser returned %d\n", parse_c_expression (buf));
  614.   }
  615. }
  616.  
  617. /* table to tell if char can be part of a C identifier. */
  618. unsigned char is_idchar[256];
  619. /* table to tell if char can be first char of a c identifier. */
  620. unsigned char is_idstart[256];
  621. /* table to tell if c is horizontal space.  isspace () thinks that
  622.    newline is space; this is not a good idea for this program. */
  623. char is_hor_space[256];
  624.  
  625. /*
  626.  * initialize random junk in the hash table and maybe other places
  627.  */
  628. initialize_random_junk ()
  629. {
  630.   register int i;
  631.  
  632.   /*
  633.    * Set up is_idchar and is_idstart tables.  These should be
  634.    * faster than saying (is_alpha (c) || c == '_'), etc.
  635.    * Must do set up these things before calling any routines tthat
  636.    * refer to them.
  637.    */
  638.   for (i = 'a'; i <= 'z'; i++) {
  639.     ++is_idchar[i - 'a' + 'A'];
  640.     ++is_idchar[i];
  641.     ++is_idstart[i - 'a' + 'A'];
  642.     ++is_idstart[i];
  643.   }
  644.   for (i = '0'; i <= '9'; i++)
  645.     ++is_idchar[i];
  646.   ++is_idchar['_'];
  647.   ++is_idstart['_'];
  648. #if DOLLARS_IN_IDENTIFIERS
  649.   ++is_idchar['$'];
  650.   ++is_idstart['$'];
  651. #endif
  652.  
  653.   /* horizontal space table */
  654.   ++is_hor_space[' '];
  655.   ++is_hor_space['\t'];
  656. }
  657.  
  658. struct hashnode *
  659. lookup (name, len, hash)
  660.      char *name;
  661.      int len;
  662.      int hash;
  663. {
  664.   return (DEFAULT_SIGNED_CHAR) ? 0 : ((struct hashnode *) -1);
  665. }
  666. #endif
  667.